package teamone;
//import robocode.HitRobotEvent;
//import robocode.Robot;
import robocode.ScannedRobotEvent;
//import robocode.WinEvent;
//import static robocode.util.Utils.normalRelativeAngleDegrees;
import java.lang.Math;
//import robocode.TeamRobot;
//import java.awt.*;

public class Movement
{
	static double eigeneX;
	static double eigeneY;
	static double DistanzX;
	static double DistanzY; 
	static double direkterDistanz;
	static double diesenWinkelDreh;
	static double RichtungSchau; // zwischen 0 und 359
	static boolean bewegt = false;
	static boolean AusweichRobot = false;
	static double statZielX;
	static double statZielY;
	static boolean ZielBesetzt = false;
	static boolean moving = false;
	
	public static void move (SimpleDrone MyRobot, double ZielX, double ZielY) {
       // Prints out all teammates
		statZielX = ZielX;
		statZielY = ZielY;
	//   String[] teammates = MyRobot.getTeammates();
		eigeneX = MyRobot.getX();
		eigeneY = MyRobot.getY();
		if (ZielX  == eigeneX && ZielY == eigeneY) {
			return;
		}
		if (ZielX >= MyRobot.fieldWidth - MyRobot.robotWidth) {
			ZielX = MyRobot.fieldWidth - MyRobot.robotWidth;
		}
		if (ZielY >= MyRobot.fieldHeight - MyRobot.robotHeight) {
			ZielY = MyRobot.fieldHeight  - MyRobot.robotHeight;
		}
		if (ZielX < MyRobot.robotWidth) {
			ZielX = MyRobot.robotWidth;
		}
		if (ZielY < MyRobot.robotHeight) {
			ZielY = MyRobot.robotHeight;
		}
		DistanzX = Math.abs (ZielX - eigeneX); // Distanz Robot und Ziel auf X (unten oder oben)
		DistanzY = Math.abs (ZielY - eigeneY); // Distanz Robot und Ziel auf Y (links oder rechts)
		direkterDistanz = Math.sqrt(DistanzX*DistanzX + DistanzY*DistanzY);
		RichtungSchau = MyRobot.getHeading();
		diesenWinkelDreh = Math.toDegrees(Math.asin(DistanzX/direkterDistanz)); // Gegenkathete - Hypothenuse

		if (ZielY >= eigeneY && ZielX >= eigeneX) {
			turnArc (MyRobot, diesenWinkelDreh - RichtungSchau);
		} 
		if (ZielY >= eigeneY && ZielX < eigeneX) {
			turnArc (MyRobot, 0 - diesenWinkelDreh - RichtungSchau);
		} 
		if (ZielY < eigeneY && ZielX >= eigeneX) {
			turnArc (MyRobot, 180 - diesenWinkelDreh - RichtungSchau);
		} 
		if (ZielY < eigeneY && ZielX < eigeneX) {
			turnArc (MyRobot, diesenWinkelDreh - RichtungSchau + 180);
		} 		// jetzt schaut der Robot zum Ziel/
		//scan();
	/*	while (direkterDistanz > 50){		
			AusweichRobot = true;	
			MyRobot.ahead (50);
			AusweichRobot = false;
			DistanzX = ZielX - MyRobot.getX(); // Distanz Robot und Ziel auf X (unten oder oben)
			DistanzY = ZielY - MyRobot.getY(); // Distanz Robot und Ziel auf Y (links oder rechts)
			direkterDistanz = Math.sqrt(DistanzX*DistanzX + DistanzY*DistanzY);
		}*/
		AusweichRobot = true;
		if (direkterDistanz < 50) {
			// MyRobot.stop();
			return;
		}
		if (ZielBesetzt) {
			direkterDistanz = direkterDistanz - 50;
		}
		MyRobot.setAhead (direkterDistanz); // der Robot bewegt sich, also gew�nscht
		moving = true;
		MyRobot.turnRadarLeft (5);
		MyRobot.turnRadarRight (10);
		MyRobot.turnRadarLeft (5);
		//MyRobot.scan();
		// beim ahead scannt der ununterbrochen
		AusweichRobot = false;
		//es onScannedRobot, wenn anderes Robot in naehe
		

		// neu berechnen
	/*	eigeneX = MyRobot.getX();
		eigeneY = MyRobot.getY();
		DistanzX = ZielX - eigeneX; // Distanz Robot und Ziel auf X (unten oder oben)
		DistanzY = ZielY - eigeneY; // Distanz Robot und Ziel auf Y (links oder rechts)
		direkterDistanz = Math.sqrt(DistanzX*DistanzX + DistanzY*DistanzY); */
		moving = false;
	}
	
		// Umkreistest
	/*	if (bewegt) {
		if ( (2 * DistanzX + getX() < getBattleFieldWidth() ) && (2 * DistanzY + getY() < getBattleFieldHeight() )
			&& (2 * DistanzX + getX() > 0) && (2 * DistanzY + getY() > 0)) {
			// bereite Umkreisen vor
			turnLeft (90);
			circular (ZielX, ZielY, direkterDistanz);
		}
		}*/

	public static void moveEvading (SimpleDrone MyRobot, double ZielX, double ZielY) {
		statZielX = ZielX;
		statZielY = ZielY;
       // Prints out all teammates
		boolean gehtnoch = true;
	   String[] teammates = MyRobot.getTeammates();
		eigeneX = MyRobot.getX();
		eigeneY = MyRobot.getY();
		if (ZielX  == eigeneX && ZielY == eigeneY) {
			return;
		}
		if (ZielX >= MyRobot.getBattleFieldWidth() - MyRobot.robotWidth) {
			ZielX = MyRobot.getBattleFieldWidth() - MyRobot.robotWidth;
		}
		if (ZielY >= MyRobot.getBattleFieldHeight() - MyRobot.robotHeight) {
			ZielY = MyRobot.getBattleFieldHeight() - MyRobot.robotHeight;
		}
		if (ZielX < MyRobot.robotWidth) {
			ZielX = MyRobot.robotWidth;
		}
		if (ZielY < MyRobot.robotHeight) {
			ZielY = MyRobot.robotHeight;
		}
		DistanzX = Math.abs (ZielX - eigeneX); // Distanz Robot und Ziel auf X (unten oder oben)
		DistanzY = Math.abs (ZielY - eigeneY); // Distanz Robot und Ziel auf Y (links oder rechts)
		direkterDistanz = Math.sqrt(DistanzX*DistanzX + DistanzY*DistanzY);
		RichtungSchau = MyRobot.getHeading();
		diesenWinkelDreh = Math.toDegrees(Math.asin(DistanzX/direkterDistanz)); // Gegenkathete - Hypothenuse

		if (ZielY >= eigeneY && ZielX >= eigeneX) {
			turnArc (MyRobot, diesenWinkelDreh - RichtungSchau);
		} 
		if (ZielY >= eigeneY && ZielX < eigeneX) {
			turnArc (MyRobot, 0 - diesenWinkelDreh - RichtungSchau);
		} 
		if (ZielY < eigeneY && ZielX >= eigeneX) {
			turnArc (MyRobot, 180 - diesenWinkelDreh - RichtungSchau);
		} 
		if (ZielY < eigeneY && ZielX < eigeneX) {
			turnArc (MyRobot, diesenWinkelDreh - RichtungSchau + 180);
		} 		// jetzt schaut der Robot zum Ziel
		AusweichRobot = true;
		if ((MyRobot.getX() + 50 * Math.sqrt (2) < MyRobot.getBattleFieldWidth() || (MyRobot.getHeading() >= 90 && MyRobot.getHeading() < 180)) // rechts
		&& (MyRobot.getY() + 50 * Math.sqrt (2) < MyRobot.getBattleFieldHeight() || (MyRobot.getHeading() >= 180 && MyRobot.getHeading() < 270)) // oben
		&& (MyRobot.getX() > 50 * Math.sqrt (2) || MyRobot.getHeading() >= 270) // Links
		&& (MyRobot.getY() > 50 * Math.sqrt (2) || (MyRobot.getHeading() >= 90 && MyRobot.getHeading() < 180))) {  // unten
			MyRobot.turnLeft (45);
			MyRobot.ahead (50);
		} else {
			MyRobot.ahead (100 * Math.sqrt (2));
			MyRobot.turnLeft (45);
		}
		AusweichRobot = false;
		while (direkterDistanz > 100 && gehtnoch) {
			DistanzX = Math.abs (ZielX - MyRobot.getX()); // Distanz Robot und Ziel auf X (unten oder oben)
			DistanzY = Math.abs (ZielY - MyRobot.getY()); // Distanz Robot und Ziel auf Y (links oder rechts)
			direkterDistanz = Math.sqrt(DistanzX*DistanzX + DistanzY*DistanzY);
			if ( (MyRobot.getX() + 100 * Math.sqrt (2) < MyRobot.getBattleFieldWidth() || MyRobot.getHeading() < 90) // rechts
			&& (MyRobot.getY() + 100 * Math.sqrt (2) < MyRobot.getBattleFieldHeight() || MyRobot.getHeading() >= 270) // oben
			&& (MyRobot.getX() > 100 * Math.sqrt (2) || (MyRobot.getHeading() >= 180 && MyRobot.getHeading() < 270)) // Links
			&& (MyRobot.getY() > 100 * Math.sqrt (2) || (MyRobot.getHeading() >= 90 && MyRobot.getHeading() < 180))) { // unten
				MyRobot.turnRight(90);
				MyRobot.ahead (100);
			} else {
				gehtnoch = false;
			}
			if ( (MyRobot.getX() + 100 * Math.sqrt (2) < MyRobot.getBattleFieldWidth() || (MyRobot.getHeading() >= 90 && MyRobot.getHeading() < 180)) // rechts
			&& (MyRobot.getY() + 100 * Math.sqrt (2) < MyRobot.getBattleFieldHeight() || (MyRobot.getHeading() >= 180 && MyRobot.getHeading() < 270)) // oben
			&& (MyRobot.getX() > 100 * Math.sqrt (2) || MyRobot.getHeading() >= 270) // Links
			&& (MyRobot.getY() > 100 * Math.sqrt (2) || (MyRobot.getHeading() >= 90 && MyRobot.getHeading() < 180))) { 
				MyRobot.turnLeft (90);
				MyRobot.ahead (100);
			} else {
				gehtnoch = false;
			}
		}

		move (MyRobot, ZielX, ZielY);
		
		//es onScannedRobot, wenn anderes Robot in naehe
		
	
		// neu berechnen
		eigeneX = MyRobot.getX();
		eigeneY = MyRobot.getY();
		DistanzX = ZielX - eigeneX; // Distanz Robot und Ziel auf X (unten oder oben)
		DistanzY = ZielY - eigeneY; // Distanz Robot und Ziel auf Y (links oder rechts)
		direkterDistanz = Math.sqrt(DistanzX*DistanzX + DistanzY*DistanzY);
		bewegt = true;
		
		// Umkreistest
	/*	if (bewegt) {
		if ( (2 * DistanzX + getX() < getBattleFieldWidth() ) && (2 * DistanzY + getY() < getBattleFieldHeight() )
			&& (2 * DistanzX + getX() > 0) && (2 * DistanzY + getY() > 0)) {
			// bereite Umkreisen vor
			turnLeft (90);
			circular (ZielX, ZielY, direkterDistanz);
		}
		}*/
	}					
	/*public void onScannedRobot(ScannedRobotEvent e) {
		if (e.getDistance() < 50) {
			if ( (e.getEnergy() * 3 < getEnergy()) && !isTeammate(e.getName()) ) {
				return;
			} else {
			setTurnRight (45);
			ahead (50);
			setTurnLeft (45);
			ahead (50);
			}
		}
	}*/
	
	///////////////////////////////////////////////////////
	
	/* Aufgabe: */
	public static void Ausweichen (SimpleDrone MyRobot, ScannedRobotEvent e, double moveX, double moveY) {
		AusweichRobot = true;
		if (!moving) {
			return;
		}
		if ((e.getDistance() < 50) && (MyRobot.isTeammate(e.getName()))) {
			//MyRobot.stop();
			MyRobot.setBack(50);
			MyRobot.setTurnRight (90);
			MyRobot.setAhead(50);
			return;
		}
		if (
			((e.getDistance() > 200) && (MyRobot.isTeammate(e.getName())) || ((e.getDistance() > 100) && (e.getDistance() < 200) && (e.getName() != MyRobot.enemyName)))) {
			if ((e.getEnergy() * 3 < MyRobot.getEnergy()) && !MyRobot.isTeammate(e.getName()) ) {
				return;
			}
			//MyRobot.stop();
			if (MyRobot.getHeading() <= 45 || MyRobot.getHeading() > 315){
				if (MyRobot.fieldWidth / 2 <= MyRobot.getX() ) {
					MyRobot.turnRight (90);
					MyRobot.setAhead (50);
				} else {
					MyRobot.turnLeft (90);
					MyRobot.setAhead (50);
				}
			} 
			if (MyRobot.getHeading() <= 135 && MyRobot.getHeading() > 45){
				if (MyRobot.fieldHeight / 2 <= MyRobot.getY() ) {
					MyRobot.turnRight (90);
					MyRobot.setAhead (50);
				} else {
					MyRobot.turnLeft (90);
					MyRobot.setAhead (50);
				}
			} 
			if (MyRobot.getHeading() <= 225 || MyRobot.getHeading() > 135){
				if (MyRobot.fieldWidth / 2 > MyRobot.getX() ) {
					MyRobot.turnRight (90);
					MyRobot.setAhead (50);
				} else {
					MyRobot.turnLeft (90);
					MyRobot.setAhead (50);
				}
			} 
			if (MyRobot.getHeading() <= 315 || MyRobot.getHeading() > 225){
				if (MyRobot.fieldHeight / 2 > MyRobot.getY() ) {
					MyRobot.turnRight (90);
					MyRobot.setAhead (50);
				} else {
					MyRobot.turnLeft (90);
					MyRobot.setAhead (50);
				}
			} 
			AusweichRobot = false;
			move (MyRobot, moveX, moveY);
		}
	}
	
	
	//+ Roboter in eine Klasse umwandeln
	//////////////////////////////////////////////////////////
	public static void ZielTest (double moveX, double moveY, double enemyX, double enemyY) {
		if ((moveX == enemyX) && (moveY == enemyY)){
			ZielBesetzt = true;
			return;
		}
		ZielBesetzt = false;
	}
	public static void turnArc (SimpleDrone MyRobot, double direction) {
		while (direction < 0.0) {
			direction = direction + 360;
		}
		while (direction > 360.0) {
			direction = direction - 360;
		}
		if (direction <= 180.0) {
			MyRobot.turnRight (direction);
		} else {
			if (direction > 0.0) {
				MyRobot.turnLeft (360.0 - direction);
			} else {
				MyRobot.turnLeft (direction + 360.0);
			}
		}
	}
}